package com.ghost.alibabaghost.utils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;

/**
 * 集合工具类
 *
 * @author Michael
 * @version 3.0
 * @date 2013年12月23日 下午2:35:47
 */
public final class CollectionUtils {

    public static final String LIST_SEPERATOR = ",";


    /**
     * 将一个集合用指定分隔符连接为一个字符串
     *
     * @param c
     * @param seperator
     * @return
     */
    public static String join(Collection<? extends Object> c, String seperator) {
        StringBuffer buf = new StringBuffer();

        if (!isEmpty(c)) {
            for (Object o : c) {
                buf.append(seperator).append(o.toString());
            }
            if (buf.length() > 0) buf.delete(0, seperator.length());
        }
        return buf.toString();
    }


    /**
     * 将一个集合用默认分隔符连接为一个字符串
     *
     * @param c
     * @return
     */
    public static String join(Collection<? extends Object> c) {
        return join(c, LIST_SEPERATOR);
    }

    /**
     * 将一个集合用默认分隔符连接为一个字符串
     *
     * @param a
     * @return
     */
    public static String join(Object[] a) {
        List<Object> c = new ArrayList<Object>();
        for (Object o : a) {
            c.add(o);
        }
        return join(c, LIST_SEPERATOR);
    }


    /**
     * 分隔一个字符串到list数组
     *
     * @param string
     * @param seperator
     * @return
     */
    public static List<String> split(String string, String seperator) {
        if (StringUtils.isNotBlank(string)) {
            String[] strs = string.split(seperator);
            if (isNotEmpty(strs)) {
                return Arrays.asList(strs);
            }
        }
        return Collections.emptyList();
    }

    /**
     * 分隔一个字符串到list数组
     *
     * @param string
     * @return
     */
    public static List<String> split(String string) {
        return split(string, LIST_SEPERATOR);
    }


    /**
     * 判断一个集合是否为空
     *
     * @param c
     * @return
     */
    public static boolean isEmpty(Collection<? extends Object> c) {
        return c == null || c.isEmpty();
    }

    /**
     * 判断一个集合是否不为空
     *
     * @param c
     * @return
     */
    public static boolean isNotEmpty(Collection<? extends Object> c) {
        return !isEmpty(c);
    }


    /**
     * 判断一个Map是否为空
     *
     * @param m
     * @return
     */
    public static boolean isEmpty(Map<? extends Object, ? extends Object> m) {
        return m == null || m.isEmpty();
    }

    /**
     * 判断一个Map是否不为空
     *
     * @param m
     * @return
     */
    public static boolean isNotEmpty(Map<? extends Object, ? extends Object> m) {
        return !isEmpty(m);
    }


    /**
     * 判断一个数组是否为空
     *
     * @param a
     * @return
     */
    public static boolean isEmpty(Object[] a) {
        return a == null || a.length == 0;
    }

    /**
     * 判断一个数组是否不为空
     *
     * @param a
     * @return
     */
    public static boolean isNotEmpty(Object[] a) {
        return !isEmpty(a);
    }


    /**
     * 判断一个对象是否是集合类型
     *
     * @param value
     * @return
     */
    public static boolean isCollection(Object value) {
        if (value == null) return false;
        if (value instanceof Collection<?>) return true;
        if (value instanceof Map<?, ?>) return true;
        if (value instanceof Object[]) return true;
        return false;
    }

    /**
     * 将集合对象拆分为一个数组
     *
     * @param value
     * @return
     */
    public static Object[] toArray(Object value) {
        if (isCollection(value)) {
            if (value instanceof Collection<?>) {
                return ((Collection<?>) value).toArray();
            } else if (value instanceof Map<?, ?>) {
                return ((Map<?, ?>) value).values().toArray();
            } else if (value instanceof Object[]) {
                return (Object[]) value;
            }
        }
        return null;
    }

}
